package com.szewec.ps.util;

import android.app.Activity;
import android.content.Context;
import android.content.res.Configuration;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.text.Editable;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewTreeObserver;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;
import android.widget.ScrollView;
import android.widget.TextView;

import com.szewec.ps.base.BaseApplication;

import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.regex.Pattern;

import static android.content.Context.INPUT_METHOD_SERVICE;

public class TextViewUtil {
    static Context context = BaseApplication.getContext();

    private TextViewUtil() {
    }

    /**
     * @param view
     * @param drawbleResouceId 例:R.drawable.arrow_down_default
     */
    public static void setDrawbleRight(TextView view, int drawbleResouceId) {
        // 使用代码设置drawableright
        Drawable drawable = context.getResources().getDrawable(drawbleResouceId);
        // / 这一步必须要做,否则不会显示.
        drawable.setBounds(0, 0, drawable.getMinimumWidth(),
                drawable.getMinimumHeight());
        view.setCompoundDrawables(null, null, drawable, null);
    }

    /**
     * 转换为字符串类型
     *
     * @param text 文本框中的值
     * @return 转换后的值, 用于参数传给后台
     */
    public static String convertDataStringForAPI(CharSequence text) {
        // 判断传入的值是否是空字符串
        if ("".contentEquals(text)) {
            return null;
        }
        return String.valueOf(text);
    }

    /**
     * 转换为字符串类型
     *
     * @param text 文本框中的值
     * @return 转换后的值, 用于参数传给后台
     */
    public static String convertDataStringForAPI(Editable text) {
        // 判断传入的值是否是空字符串
        if ("".contentEquals(text)) {
            return null;
        }
        return String.valueOf(text);
    }

    /**
     * 转换为整型
     *
     * @param text 文本框中的值
     * @return 转换后的值
     */
    public static Integer convertDataInteger(CharSequence text) {
        // 判断传入的值是否是空字符串
        if ("".contentEquals(text)) {
            return null;
        }
        if (text.toString().contains(".")) {
            return Double.valueOf(text.toString()).intValue();
        }

        return Integer.parseInt(String.valueOf(text));
    }

    /**
     * 转换为Long
     *
     * @param text 文本框中的值
     * @return 转换后的值
     */
    public static Long convertDataLong(String text) {
        // 判断传入的值是否是空字符串
        if ("".contentEquals(text)) {
            return null;
        }
        return Long.valueOf(text);
    }

    /**
     * 转换为整型
     *
     * @param text 文本框中的值
     * @return 转换后的值
     */
    public static Integer convertDataInteger(Editable text) {
        // 判断传入的值是否是空字符串
        if ("".contentEquals(text)) {
            return null;
        }
        return Integer.parseInt(String.valueOf(text));
    }

    /**
     * 转换为小数(浮点型)
     *
     * @param text 文本框中的值
     * @return 转换后的值
     */
    public static Float convertDataFloat(Editable text) {
        // 判断传入的值是否是空字符串
        if ("".contentEquals(text)) {
            return null;
        }
        return Float.parseFloat(String.valueOf(text));
    }

    /**
     * 转换为小数(double型)
     *
     * @param text 文本框中的值
     * @return 转换后的值
     */
    public static Double convertDataDouble(Editable text) {
        // 判断传入的值是否是空字符串
        if (text == null || " ".contentEquals(text) || "".contentEquals(text)) {
            return null;
        }
        return Double.parseDouble(String.valueOf(text));
    }



    public static Double convertDataDouble(String text) {
        // 判断传入的值是否是空字符串
        if (" ".equals(text) || "".equals(text) || text == null) {
            return 0.0;
        }
        return Double.valueOf(text);
    }

    /**
     * 转换为字符串
     *
     * @param text 后台返回的数据
     * @return 转换为字符串类型的值便于界面展示
     */
    public static String convertDataString(Object text) {
        // 判断传入的值是否是空字符串
        if (text == null) {
            return "";
        }
        if (text instanceof Double || text instanceof Float) {
            DecimalFormat decimalFormat = new DecimalFormat("0.00");//保留两位小数
            return String.valueOf(decimalFormat.format(text));
        } else if (text instanceof Integer) {
            return String.valueOf(text);
        } else {
            return String.valueOf(text);
        }
    }

    /**
     * 转换为字符串
     *
     * @param text 后台返回的数据
     * @return 转换为字符串类型的值便于界面展示
     */
    public static String convertDataString4(Object text) {
        // 判断传入的值是否是空字符串
        if (text == null) {
            return "";
        }
        if (text instanceof Double || text instanceof Float) {
            DecimalFormat decimalFormat = new DecimalFormat("0.0000");//保留四位小数
            return String.valueOf(decimalFormat.format(text));
        } else {
            return String.valueOf(text);
        }
    }

    /**
     * 判断是否为数据
     *
     * @param str 需要判断的字符串
     * @return 转换后的值
     */
    public static boolean isInteger(String str) {
        Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");

        return pattern.matcher(str).matches();
    }

    /**
     * 获取后台返回的下拉选项index的对应的选项(标准地层)
     *
     * @param value     后台返回的数据
     * @param arrayData 下拉列表数据
     * @return 转换后的值
     */
    public static String getSelectedValue(Integer value, String[] arrayData) {
        // 判断传入的值是否为null
        if (value == null || value <= 0 || value > arrayData.length) {
            return "";
        }
        return arrayData[value - 1];
    }

    /**
     * 字符串日期转换为date
     *
     * @param strTime
     * @param formatType
     * @return 转换后的值
     */
    public static Date stringToDate(String strTime, String formatType)
            throws ParseException {
        SimpleDateFormat formatter = new SimpleDateFormat(formatType);
        Date date = null;
        date = formatter.parse(strTime);
        return date;
    }

    /**
     * 解决字符换行混乱的现象
     *
     * @param
     * @return
     */
    public static String ToSBC(String value) {
        char c[] = value.toCharArray();
        for (int i = 0; i < c.length; i++) {
            if (c[i] == ' ') {
                c[i] = '\u3000';
            } else if (c[i] < '\177') {
                c[i] = (char) (c[i] + 65248);

            }
        }
        return new String(c);
    }

    public static String autoSplitText(final TextView tv) {
        final String rawText = tv.getText().toString(); //原始文本
        final Paint tvPaint = tv.getPaint(); //paint，包含字体等信息
        final float tvWidth = tv.getWidth() - tv.getPaddingLeft() - tv.getPaddingRight(); //控件可用宽度

        //将原始文本按行拆分
        String[] rawTextLines = rawText.replaceAll("\r", "").split("\n");
        StringBuilder sbNewText = new StringBuilder();
        for (String rawTextLine : rawTextLines) {
            if (tvPaint.measureText(rawTextLine) <= tvWidth) {
                //如果整行宽度在控件可用宽度之内，就不处理了
                sbNewText.append(rawTextLine);
            } else {
                //如果整行宽度超过控件可用宽度，则按字符测量，在超过可用宽度的前一个字符处手动换行
                float lineWidth = 0;
                for (int cnt = 0; cnt != rawTextLine.length(); ++cnt) {
                    char ch = rawTextLine.charAt(cnt);
                    lineWidth += tvPaint.measureText(String.valueOf(ch));
                    if (lineWidth <= tvWidth) {
                        sbNewText.append(ch);
                    } else {
                        sbNewText.append("\n");
                        lineWidth = 0;
                        --cnt;
                    }
                }
            }
            sbNewText.append("\n");
        }

        //把结尾多余的\n去掉
        if (!rawText.endsWith("\n")) {
            sbNewText.deleteCharAt(sbNewText.length() - 1);
        }

        return sbNewText.toString();
    }

    /**
     * 作用:防止父控件滚动对子控件滚动的影响
     *
     * @param view 视图对象
     */
    public static void requestDisallowIntercept(View view) {
        view.setOnTouchListener((v, motionEvent) -> {
            if (motionEvent.getAction() == MotionEvent.ACTION_DOWN) {
                //通知父控件不要干扰,即屏蔽父控件的该事件以及该事件之后的一切action
                v.getParent().requestDisallowInterceptTouchEvent(true);
            }
            if (motionEvent.getAction() == MotionEvent.ACTION_MOVE) {
                //通知父控件不要干扰,即屏蔽父控件的该事件以及该事件之后的一切action
                v.getParent().requestDisallowInterceptTouchEvent(true);
            }
            if (motionEvent.getAction() == MotionEvent.ACTION_UP) {
                v.getParent().requestDisallowInterceptTouchEvent(false);
            }
            return false;
        });
    }

    /**
     * 限制输入的数字最多不超过两位小数
     *
     * @param editText 输入框
     * @s editText CharSequence
     */
    public static void keepTwoDecimals(EditText editText, CharSequence s) {
        //删除.后面超过两位的数字
        if (s.toString().contains(".")) {
            if (s.length() - 1 - s.toString().indexOf(".") > 2) {
                s = s.toString().subSequence(0,
                        s.toString().indexOf(".") + 3);
                editText.setText(s);
                editText.setSelection(s.length());
            }
        }

        //如果.在起始位置,则起始位置自动补0
        if (s.toString().trim().substring(0).equals(".")) {
            s = "0" + s;
            editText.setText(s);
            editText.setSelection(2);
        }

        //如果起始位置为0并且第二位跟的不是".",则无法后续输入
        if (s.toString().startsWith("0")
                && s.toString().trim().length() > 1) {
            if (!s.toString().substring(1, 2).equals(".")) {
                editText.setText(s.subSequence(0, 1));
                editText.setSelection(1);
                return;
            }
        }
    }

    /**
     * 关闭系统的软键盘
     *
     * @param activity 组件对象
     */
    public static void closeKeyboard(Activity activity) {
        View view = activity.getWindow().peekDecorView();
        if (view != null) {
            InputMethodManager inputManger = (InputMethodManager) activity.getSystemService(INPUT_METHOD_SERVICE);
            inputManger.hideSoftInputFromWindow(view.getWindowToken(), 0);
            view.clearFocus();
        }
    }

    /**
     * 判断当前设备是手机还是平板，代码来自 Google I/O App for Android
     *
     * @param context
     * @return 平板返回 True，手机返回 False
     */
    public static boolean isPad(Context context) {
        return (context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) >= Configuration.SCREENLAYOUT_SIZE_LARGE;
    }


    /**
     * 作用: 键盘弹出时页面高度自适应
     *
     * @param activity       activity组件对象
     * @param relativeLayout 自适应布局模块
     */
    public static void activityHeightSelfAdaption(Activity activity, View relativeLayout) {
        //软键盘监听
        SoftKeyBoardListener.setListener(activity, new SoftKeyBoardListener.OnSoftKeyBoardChangeListener() {
            @Override
            public void keyBoardShow(int height) {
                // 软键盘弹出设置底部高度占位，解决可以滑动到底部的问题
                ViewGroup.LayoutParams layoutParams = relativeLayout.getLayoutParams();
                layoutParams.height = height;
                relativeLayout.setLayoutParams(layoutParams);
            }

            @Override
            public void keyBoardHide(int height) {
                ViewGroup.LayoutParams layoutParams = relativeLayout.getLayoutParams();
                layoutParams.height = 0;
                relativeLayout.setLayoutParams(layoutParams);
            }
        });
    }

    public static void controlKeyboardLayout(final ScrollView root, final Activity context) {
        root.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver
                .OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {


                Rect rect = new Rect();
                root.getWindowVisibleDisplayFrame(rect);
                int rootInvisibleHeight = root.getRootView().getHeight() - rect.bottom;
                //若不可视区域高度大于100，则键盘显示
                if (rootInvisibleHeight > 100) {
                    int[] location = new int[2];
                    View focus = context.getCurrentFocus();
                    if (focus != null) {
                        focus.getLocationInWindow(location);
                        int scrollHeight = (location[1] + focus.getHeight()) - rect.bottom;
                        if (rect.bottom < location[1] + focus.getHeight()) {
                            LogUtil.i("zzyzzy", "scrollHeight;" + scrollHeight);
                            root.scrollTo(0, scrollHeight);
                        }
                    }
                } else {
                    //键盘隐藏
                    root.scrollTo(0, 0);
                }
            }
        });
    }


    /**
     * 把请求参数拼接到URL上并返回新的URL
     * @param url 接口URL
     * @param params 请求参数
     * @return
     */
    public static String JoinUrlAndParams(String url,HashMap<String, Object> params){
        StringBuffer newUrl = params.size() > 0 ? new StringBuffer(url + "?") : new StringBuffer(url);
        for (HashMap.Entry<String, Object> entry : params.entrySet()) {
            String key = entry.getKey();
            Object value = entry.getValue();
            if(newUrl.indexOf("=") != -1){
                newUrl.append("&");
            }
            newUrl.append(key).append("=").append(value);
        }
        return newUrl.toString();
    }
}
